home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gxclip2.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  9.1 KB  |  302 lines
  1. /* Copyright (C) 1993, 2000 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gxclip2.c,v 1.3 2000/09/19 19:00:34 lpd Exp $ */
  20. /* Mask clipping for patterns */
  21. #include "memory_.h"
  22. #include "gx.h"
  23. #include "gserrors.h"
  24. #include "gsstruct.h"
  25. #include "gxdevice.h"
  26. #include "gxdevmem.h"
  27. #include "gxclip2.h"
  28.  
  29. private_st_device_tile_clip();
  30.  
  31. /* Device procedures */
  32. private dev_proc_fill_rectangle(tile_clip_fill_rectangle);
  33. private dev_proc_copy_mono(tile_clip_copy_mono);
  34. private dev_proc_copy_color(tile_clip_copy_color);
  35. private dev_proc_copy_alpha(tile_clip_copy_alpha);
  36. private dev_proc_strip_copy_rop(tile_clip_strip_copy_rop);
  37.  
  38. /* The device descriptor. */
  39. private const gx_device_tile_clip gs_tile_clip_device =
  40. {std_device_std_body_open(gx_device_tile_clip, 0, "tile clipper",
  41.               0, 0, 1, 1),
  42.  {gx_default_open_device,
  43.   gx_forward_get_initial_matrix,
  44.   gx_default_sync_output,
  45.   gx_default_output_page,
  46.   gx_default_close_device,
  47.   gx_forward_map_rgb_color,
  48.   gx_forward_map_color_rgb,
  49.   tile_clip_fill_rectangle,
  50.   gx_default_tile_rectangle,
  51.   tile_clip_copy_mono,
  52.   tile_clip_copy_color,
  53.   gx_default_draw_line,
  54.   gx_forward_get_bits,
  55.   gx_forward_get_params,
  56.   gx_forward_put_params,
  57.   gx_forward_map_cmyk_color,
  58.   gx_forward_get_xfont_procs,
  59.   gx_forward_get_xfont_device,
  60.   gx_forward_map_rgb_alpha_color,
  61.   gx_forward_get_page_device,
  62.   gx_forward_get_alpha_bits,
  63.   tile_clip_copy_alpha,
  64.   gx_forward_get_band,
  65.   gx_default_copy_rop,
  66.   gx_default_fill_path,
  67.   gx_default_stroke_path,
  68.   gx_default_fill_mask,
  69.   gx_default_fill_trapezoid,
  70.   gx_default_fill_parallelogram,
  71.   gx_default_fill_triangle,
  72.   gx_default_draw_thin_line,
  73.   gx_default_begin_image,
  74.   gx_default_image_data,
  75.   gx_default_end_image,
  76.   gx_default_strip_tile_rectangle,
  77.   tile_clip_strip_copy_rop,
  78.   gx_forward_get_clipping_box,
  79.   gx_default_begin_typed_image,
  80.   gx_forward_get_bits_rectangle,
  81.   gx_forward_map_color_rgb_alpha,
  82.   gx_no_create_compositor,
  83.   gx_forward_get_hardware_params,
  84.   gx_default_text_begin,
  85.   gx_default_finish_copydevice
  86.  }
  87. };
  88.  
  89. /* Initialize a tile clipping device from a mask. */
  90. int
  91. tile_clip_initialize(gx_device_tile_clip * cdev, const gx_strip_bitmap * tiles,
  92.              gx_device * tdev, int px, int py, gs_memory_t *mem)
  93. {
  94.     int code =
  95.     gx_mask_clip_initialize(cdev, &gs_tile_clip_device,
  96.                 (const gx_bitmap *)tiles,
  97.                 tdev, 0, 0, mem);    /* phase will be reset */
  98.  
  99.     if (code >= 0) {
  100.     cdev->tiles = *tiles;
  101.     tile_clip_set_phase(cdev, px, py);
  102.     }
  103.     return code;
  104. }
  105.  
  106. /* Set the phase of the tile. */
  107. void
  108. tile_clip_set_phase(gx_device_tile_clip * cdev, int px, int py)
  109. {
  110.     cdev->phase.x = px;
  111.     cdev->phase.y = py;
  112. }
  113.  
  114. /* Fill a rectangle by tiling with the mask. */
  115. private int
  116. tile_clip_fill_rectangle(gx_device * dev, int x, int y, int w, int h,
  117.              gx_color_index color)
  118. {
  119.     gx_device_tile_clip *cdev = (gx_device_tile_clip *) dev;
  120.     gx_device *tdev = cdev->target;
  121.  
  122.     return (*dev_proc(tdev, strip_tile_rectangle)) (tdev, &cdev->tiles,
  123.                             x, y, w, h,
  124.             gx_no_color_index, color, cdev->phase.x, cdev->phase.y);
  125. }
  126.  
  127. /* Calculate the X offset corresponding to a given Y, taking the phase */
  128. /* and shift into account. */
  129. #define x_offset(ty, cdev)\
  130.   ((cdev)->phase.x + (((ty) + (cdev)->phase.y) / (cdev)->tiles.rep_height) *\
  131.    (cdev)->tiles.rep_shift)
  132.  
  133. /* Copy a monochrome bitmap.  We divide it up into maximal chunks */
  134. /* that line up with a single tile, and then do the obvious Boolean */
  135. /* combination of the tile mask and the source. */
  136. private int
  137. tile_clip_copy_mono(gx_device * dev,
  138.         const byte * data, int sourcex, int raster, gx_bitmap_id id,
  139.             int x, int y, int w, int h,
  140.             gx_color_index color0, gx_color_index color1)
  141. {
  142.     gx_device_tile_clip *cdev = (gx_device_tile_clip *) dev;
  143.     gx_color_index color, mcolor0, mcolor1;
  144.     int ty, ny;
  145.     int code;
  146.  
  147.     setup_mask_copy_mono(cdev, color, mcolor0, mcolor1);
  148.     for (ty = y; ty < y + h; ty += ny) {
  149.     int tx, nx;
  150.     int cy = (ty + cdev->phase.y) % cdev->tiles.rep_height;
  151.     int xoff = x_offset(ty, cdev);
  152.  
  153.     ny = min(y + h - ty, cdev->tiles.size.y - cy);
  154.     if (ny > cdev->mdev.height)
  155.         ny = cdev->mdev.height;
  156.     for (tx = x; tx < x + w; tx += nx) {
  157.         int cx = (tx + xoff) % cdev->tiles.rep_width;
  158.  
  159.         nx = min(x + w - tx, cdev->tiles.size.x - cx);
  160.         /* Copy a tile slice to the memory device buffer. */
  161.         memcpy(cdev->buffer.bytes,
  162.            cdev->tiles.data + cy * cdev->tiles.raster,
  163.            cdev->tiles.raster * ny);
  164.         /* Intersect the tile with the source data. */
  165.         /* mcolor0 and mcolor1 invert the data if needed. */
  166.         /* This call can't fail. */
  167.         (*dev_proc(&cdev->mdev, copy_mono)) ((gx_device *) & cdev->mdev,
  168.                  data + (ty - y) * raster, sourcex + tx - x,
  169.                          raster, gx_no_bitmap_id,
  170.                        cx, 0, nx, ny, mcolor0, mcolor1);
  171.         /* Now copy the color through the double mask. */
  172.         code = (*dev_proc(cdev->target, copy_mono)) (cdev->target,
  173.                  cdev->buffer.bytes, cx, cdev->tiles.raster,
  174.                              gx_no_bitmap_id,
  175.                   tx, ty, nx, ny, gx_no_color_index, color);
  176.         if (code < 0)
  177.         return code;
  178.     }
  179.     }
  180.     return 0;
  181. }
  182.  
  183. /*
  184.  * Define the skeleton for the other copying operations.  We can't use the
  185.  * BitBlt tricks: we have to scan for runs of 1s.  There are many obvious
  186.  * ways to speed this up; we'll implement some if we need to.  The schema
  187.  * is:
  188.  *      FOR_RUNS(data_row, tx1, tx, ty) {
  189.  *        ... process the run ([tx1,tx),ty) ...
  190.  *      } END_FOR_RUNS();
  191.  * Free variables: cdev, data, sourcex, raster, x, y, w, h.
  192.  */
  193. #define t_next(tx)\
  194.   BEGIN {\
  195.     if ( ++cx == cdev->tiles.size.x )\
  196.       cx = 0, tp = tile_row, tbit = 0x80;\
  197.     else if ( (tbit >>= 1) == 0 )\
  198.       tp++, tbit = 0x80;\
  199.     tx++;\
  200.   } END
  201. #define FOR_RUNS(data_row, tx1, tx, ty)\
  202.     const byte *data_row = data;\
  203.     int cy = (y + cdev->phase.y) % cdev->tiles.rep_height;\
  204.     const byte *tile_row = cdev->tiles.data + cy * cdev->tiles.raster;\
  205.     int ty;\
  206. \
  207.     for ( ty = y; ty < y + h; ty++, data_row += raster ) {\
  208.       int cx = (x + x_offset(ty, cdev)) % cdev->tiles.rep_width;\
  209.       const byte *tp = tile_row + (cx >> 3);\
  210.       byte tbit = 0x80 >> (cx & 7);\
  211.       int tx;\
  212. \
  213.       for ( tx = x; tx < x + w; ) {\
  214.         int tx1;\
  215. \
  216.         /* Skip a run of 0s. */\
  217.         while ( tx < x + w && (*tp & tbit) == 0 )\
  218.           t_next(tx);\
  219.         if ( tx == x + w )\
  220.           break;\
  221.         /* Scan a run of 1s. */\
  222.         tx1 = tx;\
  223.         do {\
  224.           t_next(tx);\
  225.         } while ( tx < x + w && (*tp & tbit) != 0 );\
  226.         if_debug3('T', "[T]run x=(%d,%d), y=%d\n", tx1, tx, ty);
  227. /* (body goes here) */
  228. #define END_FOR_RUNS()\
  229.       }\
  230.       if ( ++cy == cdev->tiles.size.y )\
  231.         cy = 0, tile_row = cdev->tiles.data;\
  232.       else\
  233.         tile_row += cdev->tiles.raster;\
  234.     }
  235.  
  236. /* Copy a color rectangle. */
  237. private int
  238. tile_clip_copy_color(gx_device * dev,
  239.         const byte * data, int sourcex, int raster, gx_bitmap_id id,
  240.              int x, int y, int w, int h)
  241. {
  242.     gx_device_tile_clip *cdev = (gx_device_tile_clip *) dev;
  243.  
  244.     FOR_RUNS(data_row, txrun, tx, ty) {
  245.     /* Copy the run. */
  246.     int code = (*dev_proc(cdev->target, copy_color))
  247.     (cdev->target, data_row, sourcex + txrun - x, raster,
  248.      gx_no_bitmap_id, txrun, ty, tx - txrun, 1);
  249.  
  250.     if (code < 0)
  251.         return code;
  252.     }
  253.     END_FOR_RUNS();
  254.     return 0;
  255. }
  256.  
  257. /* Copy an alpha rectangle similarly. */
  258. private int
  259. tile_clip_copy_alpha(gx_device * dev,
  260.         const byte * data, int sourcex, int raster, gx_bitmap_id id,
  261.         int x, int y, int w, int h, gx_color_index color, int depth)
  262. {
  263.     gx_device_tile_clip *cdev = (gx_device_tile_clip *) dev;
  264.  
  265.     FOR_RUNS(data_row, txrun, tx, ty) {
  266.     /* Copy the run. */
  267.     int code = (*dev_proc(cdev->target, copy_alpha))
  268.     (cdev->target, data_row, sourcex + txrun - x, raster,
  269.      gx_no_bitmap_id, txrun, ty, tx - txrun, 1, color, depth);
  270.  
  271.     if (code < 0)
  272.         return code;
  273.     }
  274.     END_FOR_RUNS();
  275.     return 0;
  276. }
  277.  
  278. /* Copy a RasterOp rectangle similarly. */
  279. private int
  280. tile_clip_strip_copy_rop(gx_device * dev,
  281.            const byte * data, int sourcex, uint raster, gx_bitmap_id id,
  282.              const gx_color_index * scolors,
  283.        const gx_strip_bitmap * textures, const gx_color_index * tcolors,
  284.              int x, int y, int w, int h,
  285.                int phase_x, int phase_y, gs_logical_operation_t lop)
  286. {
  287.     gx_device_tile_clip *cdev = (gx_device_tile_clip *) dev;
  288.  
  289.     FOR_RUNS(data_row, txrun, tx, ty) {
  290.     /* Copy the run. */
  291.     int code = (*dev_proc(cdev->target, strip_copy_rop))
  292.     (cdev->target, data_row, sourcex + txrun - x, raster,
  293.      gx_no_bitmap_id, scolors, textures, tcolors,
  294.      txrun, ty, tx - txrun, 1, phase_x, phase_y, lop);
  295.  
  296.     if (code < 0)
  297.         return code;
  298.     }
  299.     END_FOR_RUNS();
  300.     return 0;
  301. }
  302.